/* eslint-disable */
import { Reader, util, configure, Writer } from 'protobufjs/minimal'
import * as Long from 'long'
import { Channel, Packet } from '../../../../ibc/core/channel/v1/channel'
import { Height } from '../../../../ibc/core/client/v1/client'

export const protobufPackage = 'ibc.core.channel.v1'

/**
 * MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It
 * is called by a relayer on Chain A.
 */
export interface MsgChannelOpenInit {
  portId: string
  channel: Channel | undefined
  signer: string
}

/** MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. */
export interface MsgChannelOpenInitResponse {}

/**
 * MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel
 * on Chain B.
 */
export interface MsgChannelOpenTry {
  portId: string
  /**
   * in the case of crossing hello's, when both chains call OpenInit, we need the channel identifier
   * of the previous channel in state INIT
   */
  previousChannelId: string
  channel: Channel | undefined
  counterpartyVersion: string
  proofInit: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. */
export interface MsgChannelOpenTryResponse {}

/**
 * MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge
 * the change of channel state to TRYOPEN on Chain B.
 */
export interface MsgChannelOpenAck {
  portId: string
  channelId: string
  counterpartyChannelId: string
  counterpartyVersion: string
  proofTry: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. */
export interface MsgChannelOpenAckResponse {}

/**
 * MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to
 * acknowledge the change of channel state to OPEN on Chain A.
 */
export interface MsgChannelOpenConfirm {
  portId: string
  channelId: string
  proofAck: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response type. */
export interface MsgChannelOpenConfirmResponse {}

/**
 * MsgChannelCloseInit defines a msg sent by a Relayer to Chain A
 * to close a channel with Chain B.
 */
export interface MsgChannelCloseInit {
  portId: string
  channelId: string
  signer: string
}

/** MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. */
export interface MsgChannelCloseInitResponse {}

/**
 * MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B
 * to acknowledge the change of channel state to CLOSED on Chain A.
 */
export interface MsgChannelCloseConfirm {
  portId: string
  channelId: string
  proofInit: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response type. */
export interface MsgChannelCloseConfirmResponse {}

/** MsgRecvPacket receives incoming IBC packet */
export interface MsgRecvPacket {
  packet: Packet | undefined
  proofCommitment: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgRecvPacketResponse defines the Msg/RecvPacket response type. */
export interface MsgRecvPacketResponse {}

/** MsgTimeout receives timed-out packet */
export interface MsgTimeout {
  packet: Packet | undefined
  proofUnreceived: Uint8Array
  proofHeight: Height | undefined
  nextSequenceRecv: number
  signer: string
}

/** MsgTimeoutResponse defines the Msg/Timeout response type. */
export interface MsgTimeoutResponse {}

/** MsgTimeoutOnClose timed-out packet upon counterparty channel closure. */
export interface MsgTimeoutOnClose {
  packet: Packet | undefined
  proofUnreceived: Uint8Array
  proofClose: Uint8Array
  proofHeight: Height | undefined
  nextSequenceRecv: number
  signer: string
}

/** MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. */
export interface MsgTimeoutOnCloseResponse {}

/** MsgAcknowledgement receives incoming IBC acknowledgement */
export interface MsgAcknowledgement {
  packet: Packet | undefined
  acknowledgement: Uint8Array
  proofAcked: Uint8Array
  proofHeight: Height | undefined
  signer: string
}

/** MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. */
export interface MsgAcknowledgementResponse {}

const baseMsgChannelOpenInit: object = { portId: '', signer: '' }

export const MsgChannelOpenInit = {
  encode(
    message: MsgChannelOpenInit,
    writer: Writer = Writer.create()
  ): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.channel !== undefined) {
      Channel.encode(message.channel, writer.uint32(18).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(26).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelOpenInit {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelOpenInit } as MsgChannelOpenInit
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.channel = Channel.decode(reader, reader.uint32())
          break
        case 3:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelOpenInit {
    const message = { ...baseMsgChannelOpenInit } as MsgChannelOpenInit
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (object.channel !== undefined && object.channel !== null) {
      message.channel = Channel.fromJSON(object.channel)
    } else {
      message.channel = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelOpenInit): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.channel !== undefined &&
      (obj.channel = message.channel
        ? Channel.toJSON(message.channel)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgChannelOpenInit>): MsgChannelOpenInit {
    const message = { ...baseMsgChannelOpenInit } as MsgChannelOpenInit
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (object.channel !== undefined && object.channel !== null) {
      message.channel = Channel.fromPartial(object.channel)
    } else {
      message.channel = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelOpenInitResponse: object = {}

export const MsgChannelOpenInitResponse = {
  encode(
    _: MsgChannelOpenInitResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelOpenInitResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelOpenInitResponse
    } as MsgChannelOpenInitResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelOpenInitResponse {
    const message = {
      ...baseMsgChannelOpenInitResponse
    } as MsgChannelOpenInitResponse
    return message
  },

  toJSON(_: MsgChannelOpenInitResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelOpenInitResponse>
  ): MsgChannelOpenInitResponse {
    const message = {
      ...baseMsgChannelOpenInitResponse
    } as MsgChannelOpenInitResponse
    return message
  }
}

const baseMsgChannelOpenTry: object = {
  portId: '',
  previousChannelId: '',
  counterpartyVersion: '',
  signer: ''
}

export const MsgChannelOpenTry = {
  encode(message: MsgChannelOpenTry, writer: Writer = Writer.create()): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.previousChannelId !== '') {
      writer.uint32(18).string(message.previousChannelId)
    }
    if (message.channel !== undefined) {
      Channel.encode(message.channel, writer.uint32(26).fork()).ldelim()
    }
    if (message.counterpartyVersion !== '') {
      writer.uint32(34).string(message.counterpartyVersion)
    }
    if (message.proofInit.length !== 0) {
      writer.uint32(42).bytes(message.proofInit)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(58).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelOpenTry {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelOpenTry } as MsgChannelOpenTry
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.previousChannelId = reader.string()
          break
        case 3:
          message.channel = Channel.decode(reader, reader.uint32())
          break
        case 4:
          message.counterpartyVersion = reader.string()
          break
        case 5:
          message.proofInit = reader.bytes()
          break
        case 6:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 7:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelOpenTry {
    const message = { ...baseMsgChannelOpenTry } as MsgChannelOpenTry
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (
      object.previousChannelId !== undefined &&
      object.previousChannelId !== null
    ) {
      message.previousChannelId = String(object.previousChannelId)
    } else {
      message.previousChannelId = ''
    }
    if (object.channel !== undefined && object.channel !== null) {
      message.channel = Channel.fromJSON(object.channel)
    } else {
      message.channel = undefined
    }
    if (
      object.counterpartyVersion !== undefined &&
      object.counterpartyVersion !== null
    ) {
      message.counterpartyVersion = String(object.counterpartyVersion)
    } else {
      message.counterpartyVersion = ''
    }
    if (object.proofInit !== undefined && object.proofInit !== null) {
      message.proofInit = bytesFromBase64(object.proofInit)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelOpenTry): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.previousChannelId !== undefined &&
      (obj.previousChannelId = message.previousChannelId)
    message.channel !== undefined &&
      (obj.channel = message.channel
        ? Channel.toJSON(message.channel)
        : undefined)
    message.counterpartyVersion !== undefined &&
      (obj.counterpartyVersion = message.counterpartyVersion)
    message.proofInit !== undefined &&
      (obj.proofInit = base64FromBytes(
        message.proofInit !== undefined ? message.proofInit : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgChannelOpenTry>): MsgChannelOpenTry {
    const message = { ...baseMsgChannelOpenTry } as MsgChannelOpenTry
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (
      object.previousChannelId !== undefined &&
      object.previousChannelId !== null
    ) {
      message.previousChannelId = object.previousChannelId
    } else {
      message.previousChannelId = ''
    }
    if (object.channel !== undefined && object.channel !== null) {
      message.channel = Channel.fromPartial(object.channel)
    } else {
      message.channel = undefined
    }
    if (
      object.counterpartyVersion !== undefined &&
      object.counterpartyVersion !== null
    ) {
      message.counterpartyVersion = object.counterpartyVersion
    } else {
      message.counterpartyVersion = ''
    }
    if (object.proofInit !== undefined && object.proofInit !== null) {
      message.proofInit = object.proofInit
    } else {
      message.proofInit = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelOpenTryResponse: object = {}

export const MsgChannelOpenTryResponse = {
  encode(
    _: MsgChannelOpenTryResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelOpenTryResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelOpenTryResponse
    } as MsgChannelOpenTryResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelOpenTryResponse {
    const message = {
      ...baseMsgChannelOpenTryResponse
    } as MsgChannelOpenTryResponse
    return message
  },

  toJSON(_: MsgChannelOpenTryResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelOpenTryResponse>
  ): MsgChannelOpenTryResponse {
    const message = {
      ...baseMsgChannelOpenTryResponse
    } as MsgChannelOpenTryResponse
    return message
  }
}

const baseMsgChannelOpenAck: object = {
  portId: '',
  channelId: '',
  counterpartyChannelId: '',
  counterpartyVersion: '',
  signer: ''
}

export const MsgChannelOpenAck = {
  encode(message: MsgChannelOpenAck, writer: Writer = Writer.create()): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.channelId !== '') {
      writer.uint32(18).string(message.channelId)
    }
    if (message.counterpartyChannelId !== '') {
      writer.uint32(26).string(message.counterpartyChannelId)
    }
    if (message.counterpartyVersion !== '') {
      writer.uint32(34).string(message.counterpartyVersion)
    }
    if (message.proofTry.length !== 0) {
      writer.uint32(42).bytes(message.proofTry)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(50).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(58).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelOpenAck {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelOpenAck } as MsgChannelOpenAck
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.channelId = reader.string()
          break
        case 3:
          message.counterpartyChannelId = reader.string()
          break
        case 4:
          message.counterpartyVersion = reader.string()
          break
        case 5:
          message.proofTry = reader.bytes()
          break
        case 6:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 7:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelOpenAck {
    const message = { ...baseMsgChannelOpenAck } as MsgChannelOpenAck
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = String(object.channelId)
    } else {
      message.channelId = ''
    }
    if (
      object.counterpartyChannelId !== undefined &&
      object.counterpartyChannelId !== null
    ) {
      message.counterpartyChannelId = String(object.counterpartyChannelId)
    } else {
      message.counterpartyChannelId = ''
    }
    if (
      object.counterpartyVersion !== undefined &&
      object.counterpartyVersion !== null
    ) {
      message.counterpartyVersion = String(object.counterpartyVersion)
    } else {
      message.counterpartyVersion = ''
    }
    if (object.proofTry !== undefined && object.proofTry !== null) {
      message.proofTry = bytesFromBase64(object.proofTry)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelOpenAck): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.channelId !== undefined && (obj.channelId = message.channelId)
    message.counterpartyChannelId !== undefined &&
      (obj.counterpartyChannelId = message.counterpartyChannelId)
    message.counterpartyVersion !== undefined &&
      (obj.counterpartyVersion = message.counterpartyVersion)
    message.proofTry !== undefined &&
      (obj.proofTry = base64FromBytes(
        message.proofTry !== undefined ? message.proofTry : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgChannelOpenAck>): MsgChannelOpenAck {
    const message = { ...baseMsgChannelOpenAck } as MsgChannelOpenAck
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = object.channelId
    } else {
      message.channelId = ''
    }
    if (
      object.counterpartyChannelId !== undefined &&
      object.counterpartyChannelId !== null
    ) {
      message.counterpartyChannelId = object.counterpartyChannelId
    } else {
      message.counterpartyChannelId = ''
    }
    if (
      object.counterpartyVersion !== undefined &&
      object.counterpartyVersion !== null
    ) {
      message.counterpartyVersion = object.counterpartyVersion
    } else {
      message.counterpartyVersion = ''
    }
    if (object.proofTry !== undefined && object.proofTry !== null) {
      message.proofTry = object.proofTry
    } else {
      message.proofTry = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelOpenAckResponse: object = {}

export const MsgChannelOpenAckResponse = {
  encode(
    _: MsgChannelOpenAckResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelOpenAckResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelOpenAckResponse
    } as MsgChannelOpenAckResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelOpenAckResponse {
    const message = {
      ...baseMsgChannelOpenAckResponse
    } as MsgChannelOpenAckResponse
    return message
  },

  toJSON(_: MsgChannelOpenAckResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelOpenAckResponse>
  ): MsgChannelOpenAckResponse {
    const message = {
      ...baseMsgChannelOpenAckResponse
    } as MsgChannelOpenAckResponse
    return message
  }
}

const baseMsgChannelOpenConfirm: object = {
  portId: '',
  channelId: '',
  signer: ''
}

export const MsgChannelOpenConfirm = {
  encode(
    message: MsgChannelOpenConfirm,
    writer: Writer = Writer.create()
  ): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.channelId !== '') {
      writer.uint32(18).string(message.channelId)
    }
    if (message.proofAck.length !== 0) {
      writer.uint32(26).bytes(message.proofAck)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(42).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelOpenConfirm {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelOpenConfirm } as MsgChannelOpenConfirm
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.channelId = reader.string()
          break
        case 3:
          message.proofAck = reader.bytes()
          break
        case 4:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 5:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelOpenConfirm {
    const message = { ...baseMsgChannelOpenConfirm } as MsgChannelOpenConfirm
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = String(object.channelId)
    } else {
      message.channelId = ''
    }
    if (object.proofAck !== undefined && object.proofAck !== null) {
      message.proofAck = bytesFromBase64(object.proofAck)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelOpenConfirm): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.channelId !== undefined && (obj.channelId = message.channelId)
    message.proofAck !== undefined &&
      (obj.proofAck = base64FromBytes(
        message.proofAck !== undefined ? message.proofAck : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(
    object: DeepPartial<MsgChannelOpenConfirm>
  ): MsgChannelOpenConfirm {
    const message = { ...baseMsgChannelOpenConfirm } as MsgChannelOpenConfirm
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = object.channelId
    } else {
      message.channelId = ''
    }
    if (object.proofAck !== undefined && object.proofAck !== null) {
      message.proofAck = object.proofAck
    } else {
      message.proofAck = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelOpenConfirmResponse: object = {}

export const MsgChannelOpenConfirmResponse = {
  encode(
    _: MsgChannelOpenConfirmResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelOpenConfirmResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelOpenConfirmResponse
    } as MsgChannelOpenConfirmResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelOpenConfirmResponse {
    const message = {
      ...baseMsgChannelOpenConfirmResponse
    } as MsgChannelOpenConfirmResponse
    return message
  },

  toJSON(_: MsgChannelOpenConfirmResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelOpenConfirmResponse>
  ): MsgChannelOpenConfirmResponse {
    const message = {
      ...baseMsgChannelOpenConfirmResponse
    } as MsgChannelOpenConfirmResponse
    return message
  }
}

const baseMsgChannelCloseInit: object = {
  portId: '',
  channelId: '',
  signer: ''
}

export const MsgChannelCloseInit = {
  encode(
    message: MsgChannelCloseInit,
    writer: Writer = Writer.create()
  ): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.channelId !== '') {
      writer.uint32(18).string(message.channelId)
    }
    if (message.signer !== '') {
      writer.uint32(26).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelCloseInit {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelCloseInit } as MsgChannelCloseInit
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.channelId = reader.string()
          break
        case 3:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelCloseInit {
    const message = { ...baseMsgChannelCloseInit } as MsgChannelCloseInit
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = String(object.channelId)
    } else {
      message.channelId = ''
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelCloseInit): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.channelId !== undefined && (obj.channelId = message.channelId)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgChannelCloseInit>): MsgChannelCloseInit {
    const message = { ...baseMsgChannelCloseInit } as MsgChannelCloseInit
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = object.channelId
    } else {
      message.channelId = ''
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelCloseInitResponse: object = {}

export const MsgChannelCloseInitResponse = {
  encode(
    _: MsgChannelCloseInitResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelCloseInitResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelCloseInitResponse
    } as MsgChannelCloseInitResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelCloseInitResponse {
    const message = {
      ...baseMsgChannelCloseInitResponse
    } as MsgChannelCloseInitResponse
    return message
  },

  toJSON(_: MsgChannelCloseInitResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelCloseInitResponse>
  ): MsgChannelCloseInitResponse {
    const message = {
      ...baseMsgChannelCloseInitResponse
    } as MsgChannelCloseInitResponse
    return message
  }
}

const baseMsgChannelCloseConfirm: object = {
  portId: '',
  channelId: '',
  signer: ''
}

export const MsgChannelCloseConfirm = {
  encode(
    message: MsgChannelCloseConfirm,
    writer: Writer = Writer.create()
  ): Writer {
    if (message.portId !== '') {
      writer.uint32(10).string(message.portId)
    }
    if (message.channelId !== '') {
      writer.uint32(18).string(message.channelId)
    }
    if (message.proofInit.length !== 0) {
      writer.uint32(26).bytes(message.proofInit)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(42).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgChannelCloseConfirm {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgChannelCloseConfirm } as MsgChannelCloseConfirm
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.portId = reader.string()
          break
        case 2:
          message.channelId = reader.string()
          break
        case 3:
          message.proofInit = reader.bytes()
          break
        case 4:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 5:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgChannelCloseConfirm {
    const message = { ...baseMsgChannelCloseConfirm } as MsgChannelCloseConfirm
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = String(object.portId)
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = String(object.channelId)
    } else {
      message.channelId = ''
    }
    if (object.proofInit !== undefined && object.proofInit !== null) {
      message.proofInit = bytesFromBase64(object.proofInit)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgChannelCloseConfirm): unknown {
    const obj: any = {}
    message.portId !== undefined && (obj.portId = message.portId)
    message.channelId !== undefined && (obj.channelId = message.channelId)
    message.proofInit !== undefined &&
      (obj.proofInit = base64FromBytes(
        message.proofInit !== undefined ? message.proofInit : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(
    object: DeepPartial<MsgChannelCloseConfirm>
  ): MsgChannelCloseConfirm {
    const message = { ...baseMsgChannelCloseConfirm } as MsgChannelCloseConfirm
    if (object.portId !== undefined && object.portId !== null) {
      message.portId = object.portId
    } else {
      message.portId = ''
    }
    if (object.channelId !== undefined && object.channelId !== null) {
      message.channelId = object.channelId
    } else {
      message.channelId = ''
    }
    if (object.proofInit !== undefined && object.proofInit !== null) {
      message.proofInit = object.proofInit
    } else {
      message.proofInit = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgChannelCloseConfirmResponse: object = {}

export const MsgChannelCloseConfirmResponse = {
  encode(
    _: MsgChannelCloseConfirmResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgChannelCloseConfirmResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgChannelCloseConfirmResponse
    } as MsgChannelCloseConfirmResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgChannelCloseConfirmResponse {
    const message = {
      ...baseMsgChannelCloseConfirmResponse
    } as MsgChannelCloseConfirmResponse
    return message
  },

  toJSON(_: MsgChannelCloseConfirmResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgChannelCloseConfirmResponse>
  ): MsgChannelCloseConfirmResponse {
    const message = {
      ...baseMsgChannelCloseConfirmResponse
    } as MsgChannelCloseConfirmResponse
    return message
  }
}

const baseMsgRecvPacket: object = { signer: '' }

export const MsgRecvPacket = {
  encode(message: MsgRecvPacket, writer: Writer = Writer.create()): Writer {
    if (message.packet !== undefined) {
      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim()
    }
    if (message.proofCommitment.length !== 0) {
      writer.uint32(18).bytes(message.proofCommitment)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(34).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgRecvPacket {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgRecvPacket } as MsgRecvPacket
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.packet = Packet.decode(reader, reader.uint32())
          break
        case 2:
          message.proofCommitment = reader.bytes()
          break
        case 3:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 4:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgRecvPacket {
    const message = { ...baseMsgRecvPacket } as MsgRecvPacket
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromJSON(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofCommitment !== undefined &&
      object.proofCommitment !== null
    ) {
      message.proofCommitment = bytesFromBase64(object.proofCommitment)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgRecvPacket): unknown {
    const obj: any = {}
    message.packet !== undefined &&
      (obj.packet = message.packet ? Packet.toJSON(message.packet) : undefined)
    message.proofCommitment !== undefined &&
      (obj.proofCommitment = base64FromBytes(
        message.proofCommitment !== undefined
          ? message.proofCommitment
          : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgRecvPacket>): MsgRecvPacket {
    const message = { ...baseMsgRecvPacket } as MsgRecvPacket
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromPartial(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofCommitment !== undefined &&
      object.proofCommitment !== null
    ) {
      message.proofCommitment = object.proofCommitment
    } else {
      message.proofCommitment = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgRecvPacketResponse: object = {}

export const MsgRecvPacketResponse = {
  encode(_: MsgRecvPacketResponse, writer: Writer = Writer.create()): Writer {
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgRecvPacketResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgRecvPacketResponse } as MsgRecvPacketResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgRecvPacketResponse {
    const message = { ...baseMsgRecvPacketResponse } as MsgRecvPacketResponse
    return message
  },

  toJSON(_: MsgRecvPacketResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(_: DeepPartial<MsgRecvPacketResponse>): MsgRecvPacketResponse {
    const message = { ...baseMsgRecvPacketResponse } as MsgRecvPacketResponse
    return message
  }
}

const baseMsgTimeout: object = { nextSequenceRecv: 0, signer: '' }

export const MsgTimeout = {
  encode(message: MsgTimeout, writer: Writer = Writer.create()): Writer {
    if (message.packet !== undefined) {
      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim()
    }
    if (message.proofUnreceived.length !== 0) {
      writer.uint32(18).bytes(message.proofUnreceived)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim()
    }
    if (message.nextSequenceRecv !== 0) {
      writer.uint32(32).uint64(message.nextSequenceRecv)
    }
    if (message.signer !== '') {
      writer.uint32(42).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgTimeout {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgTimeout } as MsgTimeout
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.packet = Packet.decode(reader, reader.uint32())
          break
        case 2:
          message.proofUnreceived = reader.bytes()
          break
        case 3:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 4:
          message.nextSequenceRecv = longToNumber(reader.uint64() as Long)
          break
        case 5:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgTimeout {
    const message = { ...baseMsgTimeout } as MsgTimeout
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromJSON(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofUnreceived !== undefined &&
      object.proofUnreceived !== null
    ) {
      message.proofUnreceived = bytesFromBase64(object.proofUnreceived)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (
      object.nextSequenceRecv !== undefined &&
      object.nextSequenceRecv !== null
    ) {
      message.nextSequenceRecv = Number(object.nextSequenceRecv)
    } else {
      message.nextSequenceRecv = 0
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgTimeout): unknown {
    const obj: any = {}
    message.packet !== undefined &&
      (obj.packet = message.packet ? Packet.toJSON(message.packet) : undefined)
    message.proofUnreceived !== undefined &&
      (obj.proofUnreceived = base64FromBytes(
        message.proofUnreceived !== undefined
          ? message.proofUnreceived
          : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.nextSequenceRecv !== undefined &&
      (obj.nextSequenceRecv = message.nextSequenceRecv)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgTimeout>): MsgTimeout {
    const message = { ...baseMsgTimeout } as MsgTimeout
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromPartial(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofUnreceived !== undefined &&
      object.proofUnreceived !== null
    ) {
      message.proofUnreceived = object.proofUnreceived
    } else {
      message.proofUnreceived = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (
      object.nextSequenceRecv !== undefined &&
      object.nextSequenceRecv !== null
    ) {
      message.nextSequenceRecv = object.nextSequenceRecv
    } else {
      message.nextSequenceRecv = 0
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgTimeoutResponse: object = {}

export const MsgTimeoutResponse = {
  encode(_: MsgTimeoutResponse, writer: Writer = Writer.create()): Writer {
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgTimeoutResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgTimeoutResponse } as MsgTimeoutResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgTimeoutResponse {
    const message = { ...baseMsgTimeoutResponse } as MsgTimeoutResponse
    return message
  },

  toJSON(_: MsgTimeoutResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(_: DeepPartial<MsgTimeoutResponse>): MsgTimeoutResponse {
    const message = { ...baseMsgTimeoutResponse } as MsgTimeoutResponse
    return message
  }
}

const baseMsgTimeoutOnClose: object = { nextSequenceRecv: 0, signer: '' }

export const MsgTimeoutOnClose = {
  encode(message: MsgTimeoutOnClose, writer: Writer = Writer.create()): Writer {
    if (message.packet !== undefined) {
      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim()
    }
    if (message.proofUnreceived.length !== 0) {
      writer.uint32(18).bytes(message.proofUnreceived)
    }
    if (message.proofClose.length !== 0) {
      writer.uint32(26).bytes(message.proofClose)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim()
    }
    if (message.nextSequenceRecv !== 0) {
      writer.uint32(40).uint64(message.nextSequenceRecv)
    }
    if (message.signer !== '') {
      writer.uint32(50).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgTimeoutOnClose {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgTimeoutOnClose } as MsgTimeoutOnClose
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.packet = Packet.decode(reader, reader.uint32())
          break
        case 2:
          message.proofUnreceived = reader.bytes()
          break
        case 3:
          message.proofClose = reader.bytes()
          break
        case 4:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 5:
          message.nextSequenceRecv = longToNumber(reader.uint64() as Long)
          break
        case 6:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgTimeoutOnClose {
    const message = { ...baseMsgTimeoutOnClose } as MsgTimeoutOnClose
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromJSON(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofUnreceived !== undefined &&
      object.proofUnreceived !== null
    ) {
      message.proofUnreceived = bytesFromBase64(object.proofUnreceived)
    }
    if (object.proofClose !== undefined && object.proofClose !== null) {
      message.proofClose = bytesFromBase64(object.proofClose)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (
      object.nextSequenceRecv !== undefined &&
      object.nextSequenceRecv !== null
    ) {
      message.nextSequenceRecv = Number(object.nextSequenceRecv)
    } else {
      message.nextSequenceRecv = 0
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgTimeoutOnClose): unknown {
    const obj: any = {}
    message.packet !== undefined &&
      (obj.packet = message.packet ? Packet.toJSON(message.packet) : undefined)
    message.proofUnreceived !== undefined &&
      (obj.proofUnreceived = base64FromBytes(
        message.proofUnreceived !== undefined
          ? message.proofUnreceived
          : new Uint8Array()
      ))
    message.proofClose !== undefined &&
      (obj.proofClose = base64FromBytes(
        message.proofClose !== undefined ? message.proofClose : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.nextSequenceRecv !== undefined &&
      (obj.nextSequenceRecv = message.nextSequenceRecv)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgTimeoutOnClose>): MsgTimeoutOnClose {
    const message = { ...baseMsgTimeoutOnClose } as MsgTimeoutOnClose
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromPartial(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.proofUnreceived !== undefined &&
      object.proofUnreceived !== null
    ) {
      message.proofUnreceived = object.proofUnreceived
    } else {
      message.proofUnreceived = new Uint8Array()
    }
    if (object.proofClose !== undefined && object.proofClose !== null) {
      message.proofClose = object.proofClose
    } else {
      message.proofClose = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (
      object.nextSequenceRecv !== undefined &&
      object.nextSequenceRecv !== null
    ) {
      message.nextSequenceRecv = object.nextSequenceRecv
    } else {
      message.nextSequenceRecv = 0
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgTimeoutOnCloseResponse: object = {}

export const MsgTimeoutOnCloseResponse = {
  encode(
    _: MsgTimeoutOnCloseResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgTimeoutOnCloseResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgTimeoutOnCloseResponse
    } as MsgTimeoutOnCloseResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgTimeoutOnCloseResponse {
    const message = {
      ...baseMsgTimeoutOnCloseResponse
    } as MsgTimeoutOnCloseResponse
    return message
  },

  toJSON(_: MsgTimeoutOnCloseResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgTimeoutOnCloseResponse>
  ): MsgTimeoutOnCloseResponse {
    const message = {
      ...baseMsgTimeoutOnCloseResponse
    } as MsgTimeoutOnCloseResponse
    return message
  }
}

const baseMsgAcknowledgement: object = { signer: '' }

export const MsgAcknowledgement = {
  encode(
    message: MsgAcknowledgement,
    writer: Writer = Writer.create()
  ): Writer {
    if (message.packet !== undefined) {
      Packet.encode(message.packet, writer.uint32(10).fork()).ldelim()
    }
    if (message.acknowledgement.length !== 0) {
      writer.uint32(18).bytes(message.acknowledgement)
    }
    if (message.proofAcked.length !== 0) {
      writer.uint32(26).bytes(message.proofAcked)
    }
    if (message.proofHeight !== undefined) {
      Height.encode(message.proofHeight, writer.uint32(34).fork()).ldelim()
    }
    if (message.signer !== '') {
      writer.uint32(42).string(message.signer)
    }
    return writer
  },

  decode(input: Reader | Uint8Array, length?: number): MsgAcknowledgement {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = { ...baseMsgAcknowledgement } as MsgAcknowledgement
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        case 1:
          message.packet = Packet.decode(reader, reader.uint32())
          break
        case 2:
          message.acknowledgement = reader.bytes()
          break
        case 3:
          message.proofAcked = reader.bytes()
          break
        case 4:
          message.proofHeight = Height.decode(reader, reader.uint32())
          break
        case 5:
          message.signer = reader.string()
          break
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(object: any): MsgAcknowledgement {
    const message = { ...baseMsgAcknowledgement } as MsgAcknowledgement
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromJSON(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.acknowledgement !== undefined &&
      object.acknowledgement !== null
    ) {
      message.acknowledgement = bytesFromBase64(object.acknowledgement)
    }
    if (object.proofAcked !== undefined && object.proofAcked !== null) {
      message.proofAcked = bytesFromBase64(object.proofAcked)
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromJSON(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = String(object.signer)
    } else {
      message.signer = ''
    }
    return message
  },

  toJSON(message: MsgAcknowledgement): unknown {
    const obj: any = {}
    message.packet !== undefined &&
      (obj.packet = message.packet ? Packet.toJSON(message.packet) : undefined)
    message.acknowledgement !== undefined &&
      (obj.acknowledgement = base64FromBytes(
        message.acknowledgement !== undefined
          ? message.acknowledgement
          : new Uint8Array()
      ))
    message.proofAcked !== undefined &&
      (obj.proofAcked = base64FromBytes(
        message.proofAcked !== undefined ? message.proofAcked : new Uint8Array()
      ))
    message.proofHeight !== undefined &&
      (obj.proofHeight = message.proofHeight
        ? Height.toJSON(message.proofHeight)
        : undefined)
    message.signer !== undefined && (obj.signer = message.signer)
    return obj
  },

  fromPartial(object: DeepPartial<MsgAcknowledgement>): MsgAcknowledgement {
    const message = { ...baseMsgAcknowledgement } as MsgAcknowledgement
    if (object.packet !== undefined && object.packet !== null) {
      message.packet = Packet.fromPartial(object.packet)
    } else {
      message.packet = undefined
    }
    if (
      object.acknowledgement !== undefined &&
      object.acknowledgement !== null
    ) {
      message.acknowledgement = object.acknowledgement
    } else {
      message.acknowledgement = new Uint8Array()
    }
    if (object.proofAcked !== undefined && object.proofAcked !== null) {
      message.proofAcked = object.proofAcked
    } else {
      message.proofAcked = new Uint8Array()
    }
    if (object.proofHeight !== undefined && object.proofHeight !== null) {
      message.proofHeight = Height.fromPartial(object.proofHeight)
    } else {
      message.proofHeight = undefined
    }
    if (object.signer !== undefined && object.signer !== null) {
      message.signer = object.signer
    } else {
      message.signer = ''
    }
    return message
  }
}

const baseMsgAcknowledgementResponse: object = {}

export const MsgAcknowledgementResponse = {
  encode(
    _: MsgAcknowledgementResponse,
    writer: Writer = Writer.create()
  ): Writer {
    return writer
  },

  decode(
    input: Reader | Uint8Array,
    length?: number
  ): MsgAcknowledgementResponse {
    const reader = input instanceof Uint8Array ? new Reader(input) : input
    let end = length === undefined ? reader.len : reader.pos + length
    const message = {
      ...baseMsgAcknowledgementResponse
    } as MsgAcknowledgementResponse
    while (reader.pos < end) {
      const tag = reader.uint32()
      switch (tag >>> 3) {
        default:
          reader.skipType(tag & 7)
          break
      }
    }
    return message
  },

  fromJSON(_: any): MsgAcknowledgementResponse {
    const message = {
      ...baseMsgAcknowledgementResponse
    } as MsgAcknowledgementResponse
    return message
  },

  toJSON(_: MsgAcknowledgementResponse): unknown {
    const obj: any = {}
    return obj
  },

  fromPartial(
    _: DeepPartial<MsgAcknowledgementResponse>
  ): MsgAcknowledgementResponse {
    const message = {
      ...baseMsgAcknowledgementResponse
    } as MsgAcknowledgementResponse
    return message
  }
}

/** Msg defines the ibc/channel Msg service. */
export interface Msg {
  /** ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit. */
  ChannelOpenInit(
    request: MsgChannelOpenInit
  ): Promise<MsgChannelOpenInitResponse>
  /** ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry. */
  ChannelOpenTry(request: MsgChannelOpenTry): Promise<MsgChannelOpenTryResponse>
  /** ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck. */
  ChannelOpenAck(request: MsgChannelOpenAck): Promise<MsgChannelOpenAckResponse>
  /** ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm. */
  ChannelOpenConfirm(
    request: MsgChannelOpenConfirm
  ): Promise<MsgChannelOpenConfirmResponse>
  /** ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit. */
  ChannelCloseInit(
    request: MsgChannelCloseInit
  ): Promise<MsgChannelCloseInitResponse>
  /** ChannelCloseConfirm defines a rpc handler method for MsgChannelCloseConfirm. */
  ChannelCloseConfirm(
    request: MsgChannelCloseConfirm
  ): Promise<MsgChannelCloseConfirmResponse>
  /** RecvPacket defines a rpc handler method for MsgRecvPacket. */
  RecvPacket(request: MsgRecvPacket): Promise<MsgRecvPacketResponse>
  /** Timeout defines a rpc handler method for MsgTimeout. */
  Timeout(request: MsgTimeout): Promise<MsgTimeoutResponse>
  /** TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose. */
  TimeoutOnClose(request: MsgTimeoutOnClose): Promise<MsgTimeoutOnCloseResponse>
  /** Acknowledgement defines a rpc handler method for MsgAcknowledgement. */
  Acknowledgement(
    request: MsgAcknowledgement
  ): Promise<MsgAcknowledgementResponse>
}

export class MsgClientImpl implements Msg {
  private readonly rpc: Rpc
  constructor(rpc: Rpc) {
    this.rpc = rpc
  }
  ChannelOpenInit(
    request: MsgChannelOpenInit
  ): Promise<MsgChannelOpenInitResponse> {
    const data = MsgChannelOpenInit.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelOpenInit',
      data
    )
    return promise.then((data) =>
      MsgChannelOpenInitResponse.decode(new Reader(data))
    )
  }

  ChannelOpenTry(
    request: MsgChannelOpenTry
  ): Promise<MsgChannelOpenTryResponse> {
    const data = MsgChannelOpenTry.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelOpenTry',
      data
    )
    return promise.then((data) =>
      MsgChannelOpenTryResponse.decode(new Reader(data))
    )
  }

  ChannelOpenAck(
    request: MsgChannelOpenAck
  ): Promise<MsgChannelOpenAckResponse> {
    const data = MsgChannelOpenAck.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelOpenAck',
      data
    )
    return promise.then((data) =>
      MsgChannelOpenAckResponse.decode(new Reader(data))
    )
  }

  ChannelOpenConfirm(
    request: MsgChannelOpenConfirm
  ): Promise<MsgChannelOpenConfirmResponse> {
    const data = MsgChannelOpenConfirm.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelOpenConfirm',
      data
    )
    return promise.then((data) =>
      MsgChannelOpenConfirmResponse.decode(new Reader(data))
    )
  }

  ChannelCloseInit(
    request: MsgChannelCloseInit
  ): Promise<MsgChannelCloseInitResponse> {
    const data = MsgChannelCloseInit.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelCloseInit',
      data
    )
    return promise.then((data) =>
      MsgChannelCloseInitResponse.decode(new Reader(data))
    )
  }

  ChannelCloseConfirm(
    request: MsgChannelCloseConfirm
  ): Promise<MsgChannelCloseConfirmResponse> {
    const data = MsgChannelCloseConfirm.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'ChannelCloseConfirm',
      data
    )
    return promise.then((data) =>
      MsgChannelCloseConfirmResponse.decode(new Reader(data))
    )
  }

  RecvPacket(request: MsgRecvPacket): Promise<MsgRecvPacketResponse> {
    const data = MsgRecvPacket.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'RecvPacket',
      data
    )
    return promise.then((data) =>
      MsgRecvPacketResponse.decode(new Reader(data))
    )
  }

  Timeout(request: MsgTimeout): Promise<MsgTimeoutResponse> {
    const data = MsgTimeout.encode(request).finish()
    const promise = this.rpc.request('ibc.core.channel.v1.Msg', 'Timeout', data)
    return promise.then((data) => MsgTimeoutResponse.decode(new Reader(data)))
  }

  TimeoutOnClose(
    request: MsgTimeoutOnClose
  ): Promise<MsgTimeoutOnCloseResponse> {
    const data = MsgTimeoutOnClose.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'TimeoutOnClose',
      data
    )
    return promise.then((data) =>
      MsgTimeoutOnCloseResponse.decode(new Reader(data))
    )
  }

  Acknowledgement(
    request: MsgAcknowledgement
  ): Promise<MsgAcknowledgementResponse> {
    const data = MsgAcknowledgement.encode(request).finish()
    const promise = this.rpc.request(
      'ibc.core.channel.v1.Msg',
      'Acknowledgement',
      data
    )
    return promise.then((data) =>
      MsgAcknowledgementResponse.decode(new Reader(data))
    )
  }
}

interface Rpc {
  request(
    service: string,
    method: string,
    data: Uint8Array
  ): Promise<Uint8Array>
}

declare var self: any | undefined
declare var window: any | undefined
var globalThis: any = (() => {
  if (typeof globalThis !== 'undefined') return globalThis
  if (typeof self !== 'undefined') return self
  if (typeof window !== 'undefined') return window
  if (typeof global !== 'undefined') return global
  throw 'Unable to locate global object'
})()

const atob: (b64: string) => string =
  globalThis.atob ||
  ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'))
function bytesFromBase64(b64: string): Uint8Array {
  const bin = atob(b64)
  const arr = new Uint8Array(bin.length)
  for (let i = 0; i < bin.length; ++i) {
    arr[i] = bin.charCodeAt(i)
  }
  return arr
}

const btoa: (bin: string) => string =
  globalThis.btoa ||
  ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'))
function base64FromBytes(arr: Uint8Array): string {
  const bin: string[] = []
  for (let i = 0; i < arr.byteLength; ++i) {
    bin.push(String.fromCharCode(arr[i]))
  }
  return btoa(bin.join(''))
}

type Builtin = Date | Function | Uint8Array | string | number | undefined
export type DeepPartial<T> = T extends Builtin
  ? T
  : T extends Array<infer U>
  ? Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U>
  ? ReadonlyArray<DeepPartial<U>>
  : T extends {}
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>

function longToNumber(long: Long): number {
  if (long.gt(Number.MAX_SAFE_INTEGER)) {
    throw new globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER')
  }
  return long.toNumber()
}

if (util.Long !== Long) {
  util.Long = Long as any
  configure()
}
